# -*- coding: UTF-8 -*-

###############################################
###############################################
###############################################
# Referencia do Códiogo utilizado para criação do fundo: parallax_starfield. Este código pode ser encontrado no site -> http://www.pygame.org/project-Cool+Parallax+Starfield-1845-3227.html ; http://goo.gl/8ER6A
###############################################
###############################################
###############################################


import pygame 
from random import randrange, choice 
from pygame.locals import* # importa tudo que tem no módulo.todas as funções e métodos do modulo importado serão variaveis locais do meu modulo.
import pygame, sys, os 
from sys import exit 


largura = 640
altura = 480 
MAX_STARS  = 250
STAR_SPEED = 2

def init_stars(tela): 

	""" Create the starfield """
	""" Criar o campo estrelado """

	global stars # O global indica que modificaremos os valores dessas variáveis dentro de funções. 
	stars = []
	for i in range(MAX_STARS):#Cria uma lista de números inteiros

		# A star is represented as a list with this format: [X,Y,speed]
		# Uma estrela é representada como uma lista com esse formato: [X,Y,velocidade]

		star = [randrange(0,tela.get_width() - 1),
			randrange(0,tela.get_height() - 1),
			choice([1,2,3])]
		stars.append(star)

def move_and_draw_stars(tela):

	""" Move and draw the stars in the given tela """
	""" Mover e desenhar as estrelas na tela  """

	global stars
	for star in stars:
		star[1] += star[2]

		# If the star hit the bottom border then we reposition it in the top of the tela with a random X coordinate.
		# Se a estrela atingiu a borda inferior então reposicionar-la no topo da tela com uma coordenada X aleatória.

		if star[1] >= tela.get_height():
			star[1] = 0
			star[0] = randrange(0,639)
			star[2] = choice([1,2,3])

		# Adjust the star color acording to the speed.
		# Ajuste da cor das estrelas de acordo com a velocidade.

		# The slower the star, the darker should be its color.
		# A estrela mais lenta, deve ter a cor mais escura.
		
		if star[2] == 1:
			color = (100,100,100)
		elif star[2] == 2:
			color = (190,190,190)
		elif star[2] == 3:
			color = (255,255,255)

      		# Draw the star as a rectangle.
      		# Desenhar a estrela como um retângulo.

		# The star size is proportional to its speed.
		# O tamanho da estrela é proporcional à sua velocidade.

		tela.fill(color,(star[0],star[1],star[2],star[2]))

def main():

########## Carregando imagens e sons ####################################### 

	branco = (255,255,255)
	preto = (0,0,0)
	vermelho = (255,0,0)

	########## Outros eventos ##########

	pygame.init() # iniciando
	tetonando = pygame.mixer.Sound("./arquivos/explode.ogg")
	sontiro = pygame.mixer.Sound("./arquivos/empire_laser.wav") 
	audio = pygame.mixer.Sound("./arquivos/SpaceBombers.ogg")
	audio.play(-1)
	pygame.key.set_repeat(100, 10)
	tela = pygame.display.set_mode((largura,altura)) # Dimenção da tela. 
	pygame.display.set_caption("Jetfire-Combat_UFAL")
	movimento_eixo_x, movimento_eixo_y = 370, 290 # Cordenadas iniciais da nave controlada
	velocidade_do_tiro = 60 # Velocidade do tiro
	pygame.mouse.set_cursor(*pygame.cursors.broken_x)# Transforma o pontero do mause em um X:

	########## Carregamento e conversão de imagens ##########

	voltar = pygame.image.load('./arquivos/botao_voltar.gif')
	exiti = pygame.image.load('./arquivos/exit.jpg')
	fundo_desen = pygame.image.load('./arquivos/fundo_desen.jpg')
	desenvolvedores = pygame.image.load('./arquivos/desenvolvedores.png')
	fundo_menu = pygame.image.load('./arquivos/fundo.jpg')
	iniciar = pygame.image.load('./arquivos/botao_start.gif')	
	carregando = pygame.image.load('./arquivos/loading3.gif') # pygame.imagem.load: Carregar uma imagem de um arquivo de origem. Você pode passar um nome de arquivo ou um objeto Python como arquivo.
	meteoro = pygame.image.load('./arquivos/Meteor.png')
	fundo_destruido = os.path.join("./arquivos/fundo_transparente.png") # Adicionando o desenho do fundo
	fundo = pygame.image.load(fundo_destruido).convert_alpha() # Carregando o desenho do fundo e transformando os byts da imagem em pixels alpa
	nave_destruido = os.path.join("./arquivos/car_u.png")
	nave = pygame.image.load(nave_destruido).convert_alpha()# Convert_alpha: Alterar o formato do pixel de uma imagem incluindo pixel por alphas. Converter em alfas é um tipo de transparencia que tem um não-branco como cor de fundo.  
	tiro_destruido = os.path.join("./arquivos/laser.png") # os.path: Este módulo implementa algumas funções úteis sobre caminhos. Join = Junte-se a um ou mais componentes
	tiro = pygame.image.load(tiro_destruido).convert_alpha()
	inimigo_destruido = os.path.join("./arquivos/inimigo.png")
	inimigo = pygame.image.load(inimigo_destruido).convert_alpha()
	inimigo_explo_destruido = os.path.join("./arquivos/explosionn.png")
	inimigo_explo = pygame.image.load(inimigo_explo_destruido).convert_alpha()
	inimigo_r = inimigo.get_rect() # Obter a área retangular da superfície

	########## Estrutura de texo ##########

	tamanho1 = pygame.font.SysFont('Arial',10) # Escolhe a fonte  o tamanho.
	tamanho2 = pygame.font.SysFont('Tahoma',15) # Escolhe a fonte  o tamanho.
	tamanho3 = pygame.font.SysFont('Arial Black',20)#
	tamanho4 = pygame.font.SysFont('Arial',13)

	pontos = tamanho2.render('Pontos:', 1, branco)# Redenriza a fonte com a cor branca e o texto start
	destruidos0 = tamanho2.render('Destruidos:', 1, branco)
	pontos_vida1 = tamanho2.render('100', 1, branco)
	pontos_vida2 = tamanho2.render('Pontos de Vida:', 1, branco)
	desenvolvedoress = tamanho1.render('DESENVOLVEDORES',1,branco)		
	menu_desen = tamanho3.render('DESENVOLVEDORES',1, branco)
	desenvolvedor1 = tamanho3.render('Itamar Reis Wanderley',1, branco)
	desenvolvedor2 = tamanho3.render('Justino Nogueira da Silva Junior',1, branco)
	desenvolvedor3 = tamanho3.render('Wisnner Franklin dos Santos Silva',1, branco)
	email_desen1 = tamanho4.render('itamar_reis@hotmail.com',1, preto)
	email_desen2 = tamanho4.render('jnjvirtualjustino@hotmail.com',1, preto)
	email_desen3 = tamanho4.render('wisnnerf@hotmail.com',1, preto)

########## Fim do carregamento de imagens e sons ############################
  
	controle_de_tempo = pygame.time.Clock() # Criar um objeto para ajudar a controlar o tempo. 

				   # Tempo em pygame é representado em milissegundos (1 / 1000 segundos). A maioria das plataformas têm uma resolução limitada do tempo de cerca de 10 milissegundos. Esta resolução, em milissegundos, é dada no TIMER_RESOLUTION constante.

	init_stars(tela)
	menu_desenvolvedores_sair = 0
	menu_iniciar = 0
	menu_desenvolvedores = 0
	menu_sair = 0
	mortos = 0
	contador_de_pontos = 0 # Contador de pontuação
	relogio1 = 10 # Relógio do load
	direita = 1
	posicao_eixo_x = 0 # Posição da minha nave no eixo x
	posicao_eixo_y = 0 # Posição da minha nave no eixo y
	posicao_do_cometa_no_eixo_x = 0 # Posição do cometa(carregamento da tela) no eixo x 
	posicao_do_cometa_no_eixo_y = 150 # Posição do cometa(carregamento da tela) no eixo y)
	contador_do_cometa = 0

	while 1: # while principal

		controle_de_tempo.tick(50) # Utilização da variável criada acima para ajudar a controlar o tempo.

########## Menu do jogo ###########################################################################################

		while 1:
			
			if menu_sair >= 1:
				exit()
		
	########## Entrando na tela dos desenvolvedores ##########

			if menu_desenvolvedores >= 1:

				while 1:

					if menu_desenvolvedores_sair >= 1:
						menu_desenvolvedores_sair = 0
						menu_desenvolvedores = 0 
						break

                                        for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla.
                                                if acontecimentos.type == QUIT: # se o tipo de acontecimentos for igual a 'QUIT' então exit. 
                                                        exit()			

						elif acontecimentos.type == KEYDOWN:# Evento referente a botão precionado.
                                        		if acontecimentos.key == K_ESCAPE: # K_ESCAPE = botão fechar da janela do jogo: 
                                                		exit()

						elif acontecimentos.type == MOUSEBUTTONDOWN: # O tipo de acontecimentos se refere ao mause.
							p = pygame.mouse.get_pos() # Cria uma tupla com o valor das cordenadas do mause(x,y)  
							if 513 <= p[0] <= 622 and 405 <= p[1] <= 450:
								posicao = pygame.mouse.get_pressed()
								menu_desenvolvedores_sair = menu_desenvolvedores_sair + posicao[0]

					tela.blit(fundo_desen,(0,0))
					tela.blit(menu_desen, (170,10))
					tela.blit(desenvolvedor1,(20,140))
					tela.blit(email_desen1, (20,165))
					tela.blit(desenvolvedor2,(20,180))
					tela.blit(email_desen2, (20,205))
					tela.blit(desenvolvedor3, (20,220))
					tela.blit(email_desen3, (20,245))
					tela.blit(voltar, (500,400))
					pygame.display.update() # pygame.display.flip()
						
	########## Fim da tela dos desenvolvedores ##########
			
			if menu_iniciar >= 1:
                                break
			
    			for acontecimentos in pygame.event.get():
        			if acontecimentos.type == QUIT:
            				exit()

				elif acontecimentos.type == KEYDOWN:
					if acontecimentos.key == K_ESCAPE:
						exit() 

				elif acontecimentos.type == MOUSEBUTTONDOWN:
					p = pygame.mouse.get_pos() # Cria uma tupla com o valor das cordenadas do mause(x,y)
					if 7 <= p[0] <= 105 and 11 <= p[1] <= 55: # Representa as dimenções da imagem do botão inciar
						posicao = pygame.mouse.get_pressed() # Indica qual o botão do mause foi precionado
						menu_iniciar = posicao[0] # Seleciona o primeiro botão do mause que quando clicado é igaul a 1 e quando não igual a 0.
						menu_iniciar = menu_iniciar + 1

				        elif 30 <= p[0] <= 80 and 75 <= p[1] <= 120:
                                                posicao = pygame.mouse.get_pressed()
                                                menu_desenvolvedores = posicao[0]
                                                menu_desenvolvedores = menu_desenvolvedores + 1

					elif 3 <= p[0] <= 110 and 121 <= p[1] <= 130:
						posicao = pygame.mouse.get_pressed()
                                                menu_desenvolvedores = posicao[0]
                                                menu_desenvolvedores = menu_desenvolvedores + 1

					elif 9 <= p[0] <= 109 and 155 <= p[1] <= 198:
						posicao = pygame.mouse.get_pressed()
						menu_sair = posicao[0]
						menu_sair = menu_sair + 1					

			tela.blit(fundo_menu, (0,0))
			tela.blit(iniciar, (0,0))
			tela.blit(desenvolvedores,(30,75))
			tela.blit(desenvolvedoress,(5,120))
			tela.blit(exiti,(10,155))
			pygame.display.update() # pygame.display.flip() #Atualizar a tela
    
########## Fim do menu do jogo ###########################################################################################
	        
	# Lock the framerate at 50 FPS
        # Ver os framarate com 50  FPS

########## Início da movimentação automática do load ###########################################################################################

	########## Carregar o jogo(tela de load) ##########
	
		while contador_do_cometa < 2000:
	                if posicao_do_cometa_no_eixo_x >= 590:
        	                direita = 0 # 0 = False

                	elif posicao_do_cometa_no_eixo_x <= 150:
                        	direita = 1 # 1 = True

                	if direita:
                        	posicao_do_cometa_no_eixo_x = posicao_do_cometa_no_eixo_x +10
                        	posicao_do_cometa_no_eixo_y = posicao_do_cometa_no_eixo_y + 0
                       	else:
                        	posicao_do_cometa_no_eixo_x = posicao_do_cometa_no_eixo_x - 10
                        	posicao_do_cometa_no_eixo_y = posicao_do_cometa_no_eixo_y + 0
				
             
			for acontecimentos in pygame.event.get():
				if acontecimentos.type == QUIT:
					exit()

				elif acontecimentos.type == KEYDOWN:
					if acontecimentos.key == K_ESCAPE:
						exit()

			tela.fill(preto)
			tela.blit(carregando,(0, 0))
			tela.blit(meteoro,(posicao_do_cometa_no_eixo_x, posicao_do_cometa_no_eixo_y))
			pygame.display.update() # pygame.display.flip()
			contador_do_cometa = contador_do_cometa + 1
	########## Fim do carregar o jogo(tela de load) ##########


########## Início da movimentação automática do inimigo ###########################################################################################

		if posicao_eixo_x >= 542:
			direita = 0 # 0 = False

		elif posicao_eixo_x <= 0:
			direita = 1 # 1 = True   

		if direita:
			posicao_eixo_x = posicao_eixo_x +  0.6
			posicao_eixo_y = posicao_eixo_y + 0.023

		else: 
			posicao_eixo_x = posicao_eixo_x - 0.6
			posicao_eixo_y = posicao_eixo_y + 0.023
	
########## Fim da movimentação automática do inimigo ###########################################################################################

########## Início da captura dos eventos, movimentos, tiros, quit, etc ###########################################################################################
 		
		for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla.
			if acontecimentos.type == QUIT:
				exit()

			elif acontecimentos.type == KEYDOWN: # Evento referente a botão precionado. 
		 		if acontecimentos.key == K_UP:
					if  movimento_eixo_x >= 3:
						movimento_eixo_x = movimento_eixo_x - 10

				elif acontecimentos.key == K_DOWN:
					if movimento_eixo_x < 480 - (nave.get_size()[0]*1.3):#(get_size()[0]*1.3)Cria uma tupla com o tamanho da imagem
						movimento_eixo_x = movimento_eixo_x + 10

				elif acontecimentos.key == K_LEFT:
					if movimento_eixo_y >= +5:
						movimento_eixo_y = movimento_eixo_y - 10

				elif acontecimentos.key == K_RIGHT:
					if movimento_eixo_y < 680 -(nave.get_size()[1]*1.2):
						movimento_eixo_y = movimento_eixo_y + 10

 				elif acontecimentos.key == K_ESCAPE:
					exit()

				if acontecimentos.key == K_SPACE:
					sontiro.play()
					shot_posicao_eixo_y, shot_posicao_eixo_x = movimento_eixo_x, movimento_eixo_y
					contador = 0

      					while shot_posicao_eixo_y >= 0: # O tiro chega até a posição 5 no eixo y. 

           					tela.blit(tiro, (shot_posicao_eixo_x+32,shot_posicao_eixo_y-40)) # Carregando o tiro, de acordo com a centralização da nave.
                				shot_posicao_eixo_y -= velocidade_do_tiro # Velocidade do tiro.
                      				if posicao_eixo_x-40 < shot_posicao_eixo_x < posicao_eixo_x+40 and shot_posicao_eixo_y < posicao_eixo_y+20:#determinando a area da figura do alvo		                			tela.blit(fundo, (0,0)) #Carrega o fundo, com a mesma resolução da tela.
       	      						tela.blit(nave,(movimento_eixo_y, movimento_eixo_x)) # Desenha a nave na posição x e y.
							tela.blit(inimigo_explo,(posicao_eixo_x,posicao_eixo_y)) # Desenha o inimigo.
							tetonando.play()
							mortos = mortos + 1
							contador_de_pontos = contador_de_pontos + 5
	                				pygame.display.update() # pygame.display.flip().

							break
	
            					else:
							tela.blit(fundo, (0,0)) 
		                			tela.blit(nave,(movimento_eixo_y, movimento_eixo_x)) 
                					tela.blit(inimigo,(posicao_eixo_x,posicao_eixo_y))
							pygame.display.update() # pygame.display.flip().
								
				

		destruidos = tamanho2.render(str(mortos), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 
		pontos1 = tamanho2.render(str(contador_de_pontos), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 
 		tela.fill((0,0,0)) # Preencha a tela, de cor preta (0, 0, 0).
		move_and_draw_stars(tela) # Desenha a nava do jogador na tela.
		tela.blit(inimigo,(posicao_eixo_x,posicao_eixo_y))# Desenha o inimigo.
		tela.blit(nave, (movimento_eixo_y,movimento_eixo_x)) # Desenha a nave na posição x e y.
		tela.blit(fundo, (0,0)) # Carrega o fundo, com a mesma resolução da tela.
		inimigo_r = (posicao_eixo_x,posicao_eixo_y) # Carrega a posição do inimigo.
 		pygame.mouse.set_visible (0) # Invisibilidade do mause
		tela.blit(destruidos0,(520,0)) # Conta de mortos 
		tela.blit(destruidos,(610,0)) # contador de mortos
		tela.blit(pontos,(0,0)) # Contador de pontos
		tela.blit(pontos1,(70,0)) # Contador de pontos 
		tela.blit(pontos_vida1,(610,460)) # Contador de pontos de vida
		tela.blit(pontos_vida2,(500,460)) # Contador de pontos de vida
 		pygame.display.update() # pygame.display.flip().

		
if __name__ == "__main__":

	main()

